home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gimp / 2.0 / plug-ins / pyconsole.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  20.4 KB  |  695 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import gtk
  5. import gtk.gdk as gdk
  6. import gobject
  7. import pango
  8. import gtk.keysyms as _keys
  9. import code
  10. import sys
  11. import keyword
  12. import re
  13.  
  14. def _commonprefix(m):
  15.     '''Given a list of pathnames, returns the longest common leading component'''
  16.     if not m:
  17.         return ''
  18.     prefix = m[0]
  19.     for item in m:
  20.         for i in range(len(prefix)):
  21.             if prefix[:i + 1] != item[:i + 1]:
  22.                 prefix = prefix[:i]
  23.                 if i == 0:
  24.                     return ''
  25.                 break
  26.                 continue
  27.             i == 0
  28.         
  29.     
  30.     return prefix
  31.  
  32.  
  33. class _ReadLine(object):
  34.     
  35.     class Output(object):
  36.         
  37.         def __init__(self, console, tag_name):
  38.             object.__init__(self)
  39.             self.buffer = console.get_buffer()
  40.             self.tag_name = tag_name
  41.  
  42.         
  43.         def write(self, text):
  44.             pos = self.buffer.get_iter_at_mark(self.buffer.get_insert())
  45.             self.buffer.insert_with_tags_by_name(pos, text, self.tag_name)
  46.  
  47.  
  48.     
  49.     class History(object):
  50.         
  51.         def __init__(self):
  52.             object.__init__(self)
  53.             self.items = [
  54.                 '']
  55.             self.ptr = 0
  56.             self.edited = { }
  57.  
  58.         
  59.         def commit(self, text):
  60.             if text and self.items[-1] != text:
  61.                 self.items.append(text)
  62.             
  63.             self.ptr = 0
  64.             self.edited = { }
  65.  
  66.         
  67.         def get(self, dir, text):
  68.             if len(self.items) == 1:
  69.                 return None
  70.             if text != self.items[self.ptr]:
  71.                 self.edited[self.ptr] = text
  72.             elif self.edited.has_key(self.ptr):
  73.                 del self.edited[self.ptr]
  74.             
  75.             self.ptr = self.ptr + dir
  76.             if self.ptr >= len(self.items):
  77.                 self.ptr = 0
  78.             elif self.ptr < 0:
  79.                 self.ptr = len(self.items) - 1
  80.             
  81.             
  82.             try:
  83.                 return self.edited[self.ptr]
  84.             except KeyError:
  85.                 return self.items[self.ptr]
  86.  
  87.  
  88.  
  89.     
  90.     def __init__(self, quit_func = None):
  91.         object.__init__(self)
  92.         self.quit_func = quit_func
  93.         self.set_wrap_mode(gtk.WRAP_CHAR)
  94.         self.modify_font(pango.FontDescription('Monospace'))
  95.         self.buffer = self.get_buffer()
  96.         self.buffer.connect('insert-text', self.on_buf_insert)
  97.         self.buffer.connect('delete-range', self.on_buf_delete)
  98.         self.buffer.connect('mark-set', self.on_buf_mark_set)
  99.         self.do_insert = False
  100.         self.do_delete = False
  101.         self.stdout_tag = self.buffer.create_tag('stdout', foreground = '#006000')
  102.         self.stderr_tag = self.buffer.create_tag('stderr', foreground = '#B00000')
  103.         self._stdout = _ReadLine.Output(self, 'stdout')
  104.         self._stderr = _ReadLine.Output(self, 'stderr')
  105.         self.cursor = self.buffer.create_mark('cursor', self.buffer.get_start_iter(), False)
  106.         insert = self.buffer.get_insert()
  107.         self.cursor.set_visible(True)
  108.         insert.set_visible(False)
  109.         self.ps = ''
  110.         self.in_raw_input = False
  111.         self.run_on_raw_input = None
  112.         self.tab_pressed = 0
  113.         self.history = _ReadLine.History()
  114.         self.nonword_re = re.compile('[^\\w\\._]')
  115.  
  116.     
  117.     def freeze_undo(self):
  118.         
  119.         try:
  120.             self.begin_not_undoable_action()
  121.         except:
  122.             pass
  123.  
  124.  
  125.     
  126.     def thaw_undo(self):
  127.         
  128.         try:
  129.             self.end_not_undoable_action()
  130.         except:
  131.             pass
  132.  
  133.  
  134.     
  135.     def raw_input(self, ps = None):
  136.         if ps:
  137.             self.ps = ps
  138.         else:
  139.             self.ps = ''
  140.         iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
  141.         if ps:
  142.             self.freeze_undo()
  143.             self.buffer.insert(iter, self.ps)
  144.             self.thaw_undo()
  145.         
  146.         self._ReadLine__move_cursor_to(iter)
  147.         self.scroll_to_mark(self.cursor, 0.2)
  148.         self.in_raw_input = True
  149.         if self.run_on_raw_input:
  150.             run_now = self.run_on_raw_input
  151.             self.run_on_raw_input = None
  152.             self.buffer.insert_at_cursor(run_now + '\n')
  153.         
  154.  
  155.     
  156.     def on_buf_mark_set(self, buffer, iter, mark):
  157.         if mark is not buffer.get_insert():
  158.             return None
  159.         start = self._ReadLine__get_start()
  160.         end = self._ReadLine__get_end()
  161.         if iter.compare(self._ReadLine__get_start()) >= 0 and iter.compare(self._ReadLine__get_end()) <= 0:
  162.             buffer.move_mark_by_name('cursor', iter)
  163.             self.scroll_to_mark(self.cursor, 0.2)
  164.         
  165.  
  166.     
  167.     def _ReadLine__insert(self, iter, text):
  168.         self.do_insert = True
  169.         self.buffer.insert(iter, text)
  170.         self.do_insert = False
  171.  
  172.     
  173.     def on_buf_insert(self, buf, iter, text, len):
  174.         if not (self.in_raw_input) and self.do_insert or not len:
  175.             return None
  176.         buf.stop_emission('insert-text')
  177.         lines = text.splitlines()
  178.         need_eol = False
  179.         for l in lines:
  180.             if need_eol:
  181.                 self._commit()
  182.                 iter = self._ReadLine__get_cursor()
  183.             else:
  184.                 cursor = self._ReadLine__get_cursor()
  185.                 if iter.compare(self._ReadLine__get_start()) < 0:
  186.                     iter = cursor
  187.                 elif iter.compare(self._ReadLine__get_end()) > 0:
  188.                     iter = cursor
  189.                 else:
  190.                     self._ReadLine__move_cursor_to(iter)
  191.             need_eol = True
  192.             self._ReadLine__insert(iter, l)
  193.         
  194.         self._ReadLine__move_cursor(0)
  195.  
  196.     
  197.     def _ReadLine__delete(self, start, end):
  198.         self.do_delete = True
  199.         self.buffer.delete(start, end)
  200.         self.do_delete = False
  201.  
  202.     
  203.     def on_buf_delete(self, buf, start, end):
  204.         if not (self.in_raw_input) or self.do_delete:
  205.             return None
  206.         buf.stop_emission('delete-range')
  207.         start.order(end)
  208.         line_start = self._ReadLine__get_start()
  209.         line_end = self._ReadLine__get_end()
  210.         if start.compare(line_end) > 0:
  211.             return None
  212.         if end.compare(line_start) < 0:
  213.             return None
  214.         self._ReadLine__move_cursor(0)
  215.         if end.compare(line_end) > 0:
  216.             end = line_end
  217.         
  218.         self._ReadLine__delete(start, end)
  219.  
  220.     
  221.     def do_key_press_event(self, event, parent_type):
  222.         if not self.in_raw_input:
  223.             return parent_type.do_key_press_event(self, event)
  224.         tab_pressed = self.tab_pressed
  225.         self.tab_pressed = 0
  226.         handled = True
  227.         state = event.state & (gdk.SHIFT_MASK | gdk.CONTROL_MASK | gdk.MOD1_MASK)
  228.         keyval = event.keyval
  229.         if not state:
  230.             if keyval == _keys.Return:
  231.                 self._commit()
  232.             elif keyval == _keys.Up:
  233.                 self._ReadLine__history(-1)
  234.             elif keyval == _keys.Down:
  235.                 self._ReadLine__history(1)
  236.             elif keyval == _keys.Left:
  237.                 self._ReadLine__move_cursor(-1)
  238.             elif keyval == _keys.Right:
  239.                 self._ReadLine__move_cursor(1)
  240.             elif keyval == _keys.Home:
  241.                 self._ReadLine__move_cursor(-10000)
  242.             elif keyval == _keys.End:
  243.                 self._ReadLine__move_cursor(10000)
  244.             elif keyval == _keys.Tab:
  245.                 cursor = self._ReadLine__get_cursor()
  246.                 if cursor.starts_line():
  247.                     handled = False
  248.                 else:
  249.                     cursor.backward_char()
  250.                     if cursor.get_char().isspace():
  251.                         handled = False
  252.                     else:
  253.                         self.tab_pressed = tab_pressed + 1
  254.                         self._ReadLine__complete()
  255.             else:
  256.                 handled = False
  257.         elif state == gdk.CONTROL_MASK:
  258.             if keyval == _keys.u:
  259.                 start = self._ReadLine__get_start()
  260.                 end = self._ReadLine__get_cursor()
  261.                 self._ReadLine__delete(start, end)
  262.             elif keyval == _keys.d:
  263.                 if self.quit_func:
  264.                     self.quit_func()
  265.                 
  266.             else:
  267.                 handled = False
  268.         else:
  269.             handled = False
  270.         if not handled:
  271.             return parent_type.do_key_press_event(self, event)
  272.         return True
  273.  
  274.     
  275.     def _ReadLine__history(self, dir):
  276.         text = self._get_line()
  277.         new_text = self.history.get(dir, text)
  278.         if new_text is not None:
  279.             self._ReadLine__replace_line(new_text)
  280.         
  281.         self._ReadLine__move_cursor(0)
  282.         self.scroll_to_mark(self.cursor, 0.2)
  283.  
  284.     
  285.     def _ReadLine__get_cursor(self):
  286.         return self.buffer.get_iter_at_mark(self.cursor)
  287.  
  288.     
  289.     def _ReadLine__get_start(self):
  290.         iter = self._ReadLine__get_cursor()
  291.         iter.set_line_offset(len(self.ps))
  292.         return iter
  293.  
  294.     
  295.     def _ReadLine__get_end(self):
  296.         iter = self._ReadLine__get_cursor()
  297.         if not iter.ends_line():
  298.             iter.forward_to_line_end()
  299.         
  300.         return iter
  301.  
  302.     
  303.     def _ReadLine__get_text(self, start, end):
  304.         return self.buffer.get_text(start, end, False)
  305.  
  306.     
  307.     def _ReadLine__move_cursor_to(self, iter):
  308.         self.buffer.place_cursor(iter)
  309.         self.buffer.move_mark_by_name('cursor', iter)
  310.  
  311.     
  312.     def _ReadLine__move_cursor(self, howmany):
  313.         iter = self._ReadLine__get_cursor()
  314.         end = self._ReadLine__get_cursor()
  315.         if not end.ends_line():
  316.             end.forward_to_line_end()
  317.         
  318.         line_len = end.get_line_offset()
  319.         move_to = iter.get_line_offset() + howmany
  320.         move_to = min(max(move_to, len(self.ps)), line_len)
  321.         iter.set_line_offset(move_to)
  322.         self._ReadLine__move_cursor_to(iter)
  323.  
  324.     
  325.     def _ReadLine__delete_at_cursor(self, howmany):
  326.         iter = self._ReadLine__get_cursor()
  327.         end = self._ReadLine__get_cursor()
  328.         if not end.ends_line():
  329.             end.forward_to_line_end()
  330.         
  331.         line_len = end.get_line_offset()
  332.         erase_to = iter.get_line_offset() + howmany
  333.         if erase_to > line_len:
  334.             erase_to = line_len
  335.         elif erase_to < len(self.ps):
  336.             erase_to = len(self.ps)
  337.         
  338.         end.set_line_offset(erase_to)
  339.         self._ReadLine__delete(iter, end)
  340.  
  341.     
  342.     def _ReadLine__get_width(self):
  343.         if not self.flags() & gtk.REALIZED:
  344.             return 80
  345.         layout = pango.Layout(self.get_pango_context())
  346.         letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
  347.         layout.set_text(letters)
  348.         pix_width = layout.get_pixel_size()[0]
  349.         return self.allocation.width * len(letters) / pix_width
  350.  
  351.     
  352.     def _ReadLine__print_completions(self, completions):
  353.         line_start = self._ReadLine__get_text(self._ReadLine__get_start(), self._ReadLine__get_cursor())
  354.         line_end = self._ReadLine__get_text(self._ReadLine__get_cursor(), self._ReadLine__get_end())
  355.         iter = self.buffer.get_end_iter()
  356.         self._ReadLine__move_cursor_to(iter)
  357.         self._ReadLine__insert(iter, '\n')
  358.         width = max(self._ReadLine__get_width(), 4)
  359.         max_width = []([ len(s) for s in completions ])
  360.         n_columns = max(int(width / (max_width + 1)), 1)
  361.         col_width = int(width / n_columns)
  362.         total = len(completions)
  363.         col_length = total / n_columns
  364.         col_length = max(col_length, 1)
  365.         if col_length == 1:
  366.             n_columns = total
  367.             col_width = width / total
  368.         
  369.         for i in range(col_length):
  370.             for j in range(n_columns):
  371.                 ind = i + j * col_length
  372.                 if ind < total:
  373.                     if j == n_columns - 1:
  374.                         n_spaces = 0
  375.                     else:
  376.                         n_spaces = col_width - len(completions[ind])
  377.                     self._ReadLine__insert(iter, completions[ind] + ' ' * n_spaces)
  378.                     continue
  379.             
  380.             self._ReadLine__insert(iter, '\n')
  381.         
  382.         self._ReadLine__insert(iter, '%s%s%s' % (self.ps, line_start, line_end))
  383.         iter.set_line_offset(len(self.ps) + len(line_start))
  384.         self._ReadLine__move_cursor_to(iter)
  385.         self.scroll_to_mark(self.cursor, 0.2)
  386.  
  387.     
  388.     def _ReadLine__complete(self):
  389.         text = self._ReadLine__get_text(self._ReadLine__get_start(), self._ReadLine__get_cursor())
  390.         start = ''
  391.         word = text
  392.         nonwords = self.nonword_re.findall(text)
  393.         if nonwords:
  394.             last = text.rfind(nonwords[-1]) + len(nonwords[-1])
  395.             start = text[:last]
  396.             word = text[last:]
  397.         
  398.         completions = self.complete(word)
  399.         if completions:
  400.             prefix = _commonprefix(completions)
  401.             if prefix != word:
  402.                 start_iter = self._ReadLine__get_start()
  403.                 start_iter.forward_chars(len(start))
  404.                 end_iter = start_iter.copy()
  405.                 end_iter.forward_chars(len(word))
  406.                 self._ReadLine__delete(start_iter, end_iter)
  407.                 self._ReadLine__insert(end_iter, prefix)
  408.             elif self.tab_pressed > 1:
  409.                 self.freeze_undo()
  410.                 self._ReadLine__print_completions(completions)
  411.                 self.thaw_undo()
  412.                 self.tab_pressed = 0
  413.             
  414.         
  415.  
  416.     
  417.     def complete(self, text):
  418.         pass
  419.  
  420.     
  421.     def _get_line(self):
  422.         start = self._ReadLine__get_start()
  423.         end = self._ReadLine__get_end()
  424.         return self.buffer.get_text(start, end, False)
  425.  
  426.     
  427.     def _ReadLine__replace_line(self, new_text):
  428.         start = self._ReadLine__get_start()
  429.         end = self._ReadLine__get_end()
  430.         self._ReadLine__delete(start, end)
  431.         self._ReadLine__insert(end, new_text)
  432.  
  433.     
  434.     def _commit(self):
  435.         end = self._ReadLine__get_cursor()
  436.         if not end.ends_line():
  437.             end.forward_to_line_end()
  438.         
  439.         text = self._get_line()
  440.         self._ReadLine__move_cursor_to(end)
  441.         self.freeze_undo()
  442.         self._ReadLine__insert(end, '\n')
  443.         self.in_raw_input = False
  444.         self.history.commit(text)
  445.         self.do_raw_input(text)
  446.         self.thaw_undo()
  447.  
  448.     
  449.     def do_raw_input(self, text):
  450.         pass
  451.  
  452.  
  453.  
  454. class _Console(_ReadLine, code.InteractiveInterpreter):
  455.     
  456.     def __init__(self, locals = None, banner = None, completer = None, use_rlcompleter = True, start_script = None, quit_func = None):
  457.         _ReadLine.__init__(self, quit_func)
  458.         code.InteractiveInterpreter.__init__(self, locals)
  459.         self.locals['__console__'] = self
  460.         self.start_script = start_script
  461.         self.completer = completer
  462.         self.banner = banner
  463.         if not (self.completer) and use_rlcompleter:
  464.             
  465.             try:
  466.                 import rlcompleter
  467.                 self.completer = rlcompleter.Completer()
  468.             except ImportError:
  469.                 pass
  470.             except:
  471.                 None<EXCEPTION MATCH>ImportError
  472.             
  473.  
  474.         None<EXCEPTION MATCH>ImportError
  475.         self.ps1 = '>>> '
  476.         self.ps2 = '... '
  477.         self._Console__start()
  478.         self.run_on_raw_input = start_script
  479.         self.raw_input(self.ps1)
  480.  
  481.     
  482.     def _Console__start(self):
  483.         self.cmd_buffer = ''
  484.         self.freeze_undo()
  485.         self.thaw_undo()
  486.         self.do_delete = True
  487.         self.buffer.set_text('')
  488.         self.do_delete = False
  489.         if self.banner:
  490.             iter = self.buffer.get_start_iter()
  491.             self.buffer.insert_with_tags_by_name(iter, self.banner, 'stdout')
  492.             if not iter.starts_line():
  493.                 self.buffer.insert(iter, '\n')
  494.             
  495.         
  496.  
  497.     
  498.     def clear(self, start_script = None):
  499.         if start_script is None:
  500.             start_script = self.start_script
  501.         else:
  502.             self.start_script = start_script
  503.         self._Console__start()
  504.         self.run_on_raw_input = start_script
  505.  
  506.     
  507.     def do_raw_input(self, text):
  508.         if self.cmd_buffer:
  509.             cmd = self.cmd_buffer + '\n' + text
  510.         else:
  511.             cmd = text
  512.         saved_stdout = sys.stdout
  513.         saved_stderr = sys.stderr
  514.         sys.stdout = self._stdout
  515.         sys.stderr = self._stderr
  516.         if self.runsource(cmd):
  517.             self.cmd_buffer = cmd
  518.             ps = self.ps2
  519.         else:
  520.             self.cmd_buffer = ''
  521.             ps = self.ps1
  522.         sys.stdout = saved_stdout
  523.         sys.stderr = saved_stderr
  524.         self.raw_input(ps)
  525.  
  526.     
  527.     def do_command(self, code):
  528.         
  529.         try:
  530.             eval(code, self.locals)
  531.         except SystemExit:
  532.             raise 
  533.         except:
  534.             self.showtraceback()
  535.  
  536.  
  537.     
  538.     def runcode(self, code):
  539.         if gtk.pygtk_version[1] < 8:
  540.             self.do_command(code)
  541.         else:
  542.             self.emit('command', code)
  543.  
  544.     
  545.     def exec_command(self, command):
  546.         if self._get_line():
  547.             self._commit()
  548.         
  549.         self.buffer.insert_at_cursor(command)
  550.         self._commit()
  551.  
  552.     
  553.     def complete_attr(self, start, end):
  554.         
  555.         try:
  556.             obj = eval(start, self.locals)
  557.             strings = dir(obj)
  558.             if end:
  559.                 completions = { }
  560.                 for s in strings:
  561.                     if s.startswith(end):
  562.                         completions[s] = None
  563.                         continue
  564.                 
  565.                 completions = completions.keys()
  566.             else:
  567.                 completions = strings
  568.             completions.sort()
  569.             return [ start + '.' + s for s in completions ]
  570.         except:
  571.             return None
  572.  
  573.  
  574.     
  575.     def complete(self, text):
  576.         if self.completer:
  577.             completions = []
  578.             i = 0
  579.             
  580.             try:
  581.                 while None:
  582.                     s = self.completer.complete(text, i)
  583.                     if s:
  584.                         completions.append(s)
  585.                         i = i + 1
  586.                         continue
  587.                     completions.sort()
  588.                     return completions
  589.             except NameError:
  590.                 return None
  591.             
  592.  
  593.         None<EXCEPTION MATCH>NameError
  594.         dot = text.rfind('.')
  595.         if dot >= 0:
  596.             return self.complete_attr(text[:dot], text[dot + 1:])
  597.         completions = { }
  598.         strings = keyword.kwlist
  599.         if self.locals:
  600.             strings.extend(self.locals.keys())
  601.         
  602.         
  603.         try:
  604.             strings.extend(eval('globals()', self.locals).keys())
  605.         except:
  606.             pass
  607.  
  608.         
  609.         try:
  610.             exec 'import __builtin__' in self.locals
  611.             strings.extend(eval('dir(__builtin__)', self.locals))
  612.         except:
  613.             pass
  614.  
  615.         for s in strings:
  616.             if s.startswith(text):
  617.                 completions[s] = None
  618.                 continue
  619.         
  620.         completions = completions.keys()
  621.         completions.sort()
  622.         return completions
  623.  
  624.  
  625.  
  626. def ReadLineType(t = gtk.TextView):
  627.     
  628.     class readline((t, _ReadLine)):
  629.         
  630.         def __init__(self, *args, **kwargs):
  631.             t.__init__(self)
  632.             _ReadLine.__init__(self, *args, **kwargs)
  633.  
  634.         
  635.         def do_key_press_event(self, event):
  636.             return _ReadLine.do_key_press_event(self, event, t)
  637.  
  638.  
  639.     gobject.type_register(readline)
  640.     return readline
  641.  
  642.  
  643. def ConsoleType(t = gtk.TextView):
  644.     
  645.     class console_type((t, _Console)):
  646.         __gsignals__ = {
  647.             'command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object,)),
  648.             'key-press-event': 'override' }
  649.         
  650.         def __init__(self, *args, **kwargs):
  651.             if gtk.pygtk_version[1] < 8:
  652.                 gobject.GObject.__init__(self)
  653.             else:
  654.                 t.__init__(self)
  655.             _Console.__init__(self, *args, **kwargs)
  656.  
  657.         
  658.         def do_command(self, code):
  659.             return _Console.do_command(self, code)
  660.  
  661.         
  662.         def do_key_press_event(self, event):
  663.             return _Console.do_key_press_event(self, event, t)
  664.  
  665.  
  666.     if gtk.pygtk_version[1] < 8:
  667.         gobject.type_register(console_type)
  668.     
  669.     return console_type
  670.  
  671. ReadLine = ReadLineType()
  672. Console = ConsoleType()
  673.  
  674. def _make_window():
  675.     window = gtk.Window()
  676.     window.set_title('pyconsole.py')
  677.     swin = gtk.ScrolledWindow()
  678.     swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
  679.     window.add(swin)
  680.     console = Console(banner = 'Hello there!', use_rlcompleter = False, start_script = 'from gtk import *\n')
  681.     swin.add(console)
  682.     window.set_default_size(500, 400)
  683.     window.show_all()
  684.     if not gtk.main_level():
  685.         window.connect('destroy', gtk.main_quit)
  686.         gtk.main()
  687.     
  688.     return console
  689.  
  690. if __name__ == '__main__':
  691.     if len(sys.argv) < 2 or sys.argv[1] != '-gimp':
  692.         _make_window()
  693.     
  694.  
  695.